package com.zjsru.plan2023.other;

/**
 * @Author: CookLee
 * @Date: 2023/7/30
 * 行相等的最少多米诺旋转
 * 输入：tops = [2,1,2,4,2,2], bottoms = [5,2,6,2,3,2]
 * 输出：2
 * 解释：
 * 图一表示：在我们旋转之前， tops 和 bottoms 给出的多米诺牌。
 * 如果我们旋转第二个和第四个多米诺骨牌，我们可以使上面一行中的每个值都等于 2，如图二所示。
 * \
 * 输入：tops = [3,5,1,2,3], bottoms = [3,6,3,3,4]
 * 输出：-1
 * 解释： 在这种情况下，不可能旋转多米诺牌使一行的值相等。
 */
public class MinDominoRotations {
    
    /**
     * 贪心
     *
     * @param tops    上衣
     * @param bottoms 底部
     * @return int
     */
    public int minDominoRotations(int[] tops, int[] bottoms) {
        //要求是转换后至少一行的数全相等，只考虑第一个数字即可，如果第一个数字处理后的结果为-1，那么不可能存在解
        int ans = this.helper(tops[0], tops, bottoms);
        //ans=-1，但是B[0]=A[0] 则不需要再去对B[0]做同样的操作，这里直接返回-1
        if (ans != -1 || tops[0] == bottoms[0]) {
            return ans;
        }
        return this.helper(bottoms[0], tops, bottoms);
    }
    
    /**
     * 助手
     *
     * @param firstNumber 第一个数字
     * @param tops        第一个数组
     * @param bottoms     第二个数组
     * @return int
     */
    private int helper(int firstNumber, int[] tops, int[] bottoms) {
        int topLen = tops.length;
        int topCount = 0 ;
        int bottomCount = 0;
        //模拟
        for (int i = 0; i < topLen; i++) {
            if (tops[i] != firstNumber && bottoms[i] != firstNumber) {
                return -1;
            } else if (tops[i] != firstNumber) {
                topCount++;
            } else if (bottoms[i] != firstNumber) {
                bottomCount++;
            }
        }
        return Math.min(topCount, bottomCount);
    }

    public int minDominoRotations2(int[] tops, int[] bottoms) {
        int n = tops.length, ans = n + 1;
        //1 <= tops[i], bottoms[i] <= 6
        for (int i = 1; i <= 6; i++) {
            boolean f = true;
            int c1 = 0, c2 = 0;
            for (int j = 0; j < n; j++) {
                if (tops[j] != i && bottoms[j] != i) {
                    f = false;
                    break;
                } else if (bottoms[j] != i) {
                    c1++;
                } else if (tops[j] != i) {
                    c2++;
                }
            }
            if (f) {
                ans = Math.min(ans, Math.min(c1, c2));
            }
        }
        return ans == n + 1 ? -1 : ans;
    }
    
    public static void main(String[] args) {
        MinDominoRotations minDominoRotations = new MinDominoRotations();
        int[] tops = new int[]{2,1,2,4,2,2};
        int[] bottoms = new int[]{5,2,6,2,3,2};
        System.out.println(minDominoRotations.minDominoRotations(tops, bottoms));
        
    }
}
